package com.nuo.laboratory.jdk;

import org.junit.Test;

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author LGC
 * @date 2022/3/30 11:46
 */
public class StreamTest {

    /**
     * map 对元素进行修改
     * reduce 可以将所有元素进行合计
     */
    @Test
    public void testMap() {
        List<Integer> list = Arrays.asList(100, 100);
        Double aDouble = list.stream().map((cost) -> 0.9 * cost).reduce(new BinaryOperator<Double>() {
            @Override
            public Double apply(Double aDouble, Double aDouble2) {
                return aDouble + aDouble2;
            }
        }).get();
        System.out.println("打折后价格 : " + aDouble);
    }

    /**
     * filter 过滤出符合条件的元素
     */
    @Test
    public void testFilter() {
        List<Integer> list = Arrays.asList(100, 122, 324, 342, 3, 2, 34, 3333);
        List<Integer> collect = list.stream().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer < 100;
            }
        }).collect(Collectors.toList());
        System.out.println("小于一百的数：" + collect);
    }

    @Test
    public void testMatch() {
        List<String> list = Arrays.asList("a", "ab", "ac");
        boolean a = list.stream().allMatch(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("a");
            }
        });
        System.out.println("元素是否是否都以a 开头：" + a);
    }

    /**
     * 扁平化处理
     * 一个集合中元素也是集合 合并成一个集合输出
     */
    @Test
    public void testFlatMap() {
        // 将所有字符串按"-"分割然后放到一个大集合中
        List<String> list = Arrays.asList("AB-CD", "AB-EF-GH", "IG-KL");

        List<Object> collect = list.stream().flatMap(new Function<String, Stream<?>>() {
            @Override
            public Stream<?> apply(String s) {
                return Stream.of(s.split("-"));
            }
        }).collect(Collectors.toList());

        System.out.println(collect);

    }

    /**
     * String.join 指定分隔符连接字符串
     * String.chars 变成char字符流
     * String.CASE_INSENSITIVE_ORDER 不分大小写排序
     * 正则表达式模式串
     */
    @Test
    public void testString() {
        // String.join
        String join = String.join(":", "foobar", "foo", "bar");
        System.out.println(join);

        // String.chars
        String collect = "foobar:foo:bar".chars().distinct().mapToObj(c -> String.valueOf((char) c))
                .sorted(Comparator.comparing(s -> s, String.CASE_INSENSITIVE_ORDER))
                .collect(Collectors.joining());
        System.out.println(collect);

        // 正则表达式模式串
        String bar = Pattern.compile(":")
                .splitAsStream("foobar:foo:bar")
                .filter(s -> s.contains("bar"))
                .collect(Collectors.joining(":"));
        System.out.println(bar);

        Pattern pattern = Pattern.compile(".*@gmail\\.com");
        List<String> stringList = Stream.of("bob@gmail.com", "alice@hotmail.com")
                .filter(pattern.asPredicate())
                .collect(Collectors.toList());
        System.out.println(stringList);



    }


    /**
     * 素数也称为质数
     * 大于1的自然数，能被1和它本身整除，不能被其它自然数整除
     * 等差数列= an = a1 +(n-1)*d
     */
    @Test
    public void zishu() {
        // 等差素数
        for (int i = 0; i < 10000; i++) {
            if (isPrime(i)) {
                for (int j = 1; j < 10000; j++) {
                    if (isPrime(i + j) && isPrime(i + 2 * j) && isPrime(i + 3 * j)
                            && isPrime(i + 4 * j) && isPrime(i + 5 * j) && isPrime(i + 6 * j)
                            && isPrime(i + 7 * j) && isPrime(i + 8 * j) && isPrime(i + 9 * j)) {
                        System.out.println("公差为：" + j);
                        break;
                    }
                }
            }
        }
    }

    private boolean isPrime(int n) {
        for (int i = 2; i < Math.sqrt(n); i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * 指定范围内质数（素数）
     * 质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数
     */
    public List<Integer> getZishu(int start, int end) {
        List<Integer> list = new ArrayList<>();
        for (; start < end; start++) {
            boolean rs = true;
            for (int j = 2; j < start; j++) {
                if (start % j == 0) {
                    rs = false;
                    break;
                }
            }
            if (rs) {
                list.add(start);
            }
        }
        return list;
    }

    public static void main(String[] args) {
        StreamTest streamTest = new StreamTest();
        System.out.println(streamTest.getZishu(100, 1000));
    }


}
